"""
交互式模式模块
"""
import sys
import os
import shutil
from typing import Dict, List, Optional, Callable, Any, Tuple
from prompt_toolkit import PromptSession
from prompt_toolkit.completion import WordCompleter, NestedCompleter
from prompt_toolkit.styles import Style
from prompt_toolkit.formatted_text import HTML
from prompt_toolkit.history import FileHistory
from prompt_toolkit.auto_suggest import AutoSuggestFromHistory
from prompt_toolkit.key_binding import KeyBindings
from prompt_toolkit.shortcuts import clear
from prompt_toolkit.filters import Condition
from prompt_toolkit.document import Document
from prompt_toolkit.completion import Completion

from rich.console import Console
from rich.panel import Panel
from rich.table import Table
from rich.syntax import Syntax
from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TaskProgressColumn, TimeRemainingColumn
from rich.markdown import Markdown
from rich.live import Live
from rich.tree import Tree
from rich.prompt import Prompt, Confirm
from rich.traceback import install as install_rich_traceback

# 安装Rich的异常跟踪
install_rich_traceback()

class CommandCompleter(NestedCompleter):
    """增强的命令补全器"""
    
    def __init__(self, commands_dict, *args, **kwargs):
        """初始化命令补全器
        
        Args:
            commands_dict: 命令字典
        """
        super().__init__(*args, **kwargs)
        self.commands_dict = commands_dict
        
    def get_completions(self, document, complete_event):
        """获取补全项
        
        Args:
            document: 文档对象
            complete_event: 补全事件
            
        Yields:
            补全项
        """
        text = document.text
        
        # 分割命令和参数
        parts = text.split()
        
        # 如果是空行或只有空格，显示所有命令
        if not parts:
            for cmd, info in self.commands_dict.items():
                help_text = info.get('help', '')
                yield Completion(
                    cmd,
                    start_position=0,
                    display_meta=help_text
                )
            return
            
        # 如果是命令名称的一部分
        if len(parts) == 1 and not text.endswith(' '):
            cmd_part = parts[0]
            for cmd, info in self.commands_dict.items():
                if cmd.startswith(cmd_part):
                    help_text = info.get('help', '')
                    yield Completion(
                        cmd,
                        start_position=-len(cmd_part),
                        display_meta=help_text
                    )
            return
            
        # 如果已经输入了命令，补全选项
        if len(parts) >= 1:
            cmd = parts[0]
            if cmd in self.commands_dict and 'options' in self.commands_dict[cmd]:
                # 检查最后一个部分是否是选项的开始
                if text.endswith(' '):
                    # 如果以空格结尾，提供所有未使用的选项
                    used_options = set()
                    for i in range(1, len(parts)):
                        if parts[i].startswith('--'):
                            used_options.add(parts[i])
                    
                    for opt, desc in self.commands_dict[cmd]['options'].items():
                        if opt not in used_options:
                            yield Completion(
                                opt,
                                start_position=0,
                                display_meta=desc
                            )
                else:
                    # 如果不以空格结尾，检查最后一个部分是否是选项的开始
                    last_part = parts[-1]
                    if last_part.startswith('--'):
                        for opt, desc in self.commands_dict[cmd]['options'].items():
                            if opt.startswith(last_part):
                                yield Completion(
                                    opt,
                                    start_position=-len(last_part),
                                    display_meta=desc
                                )
                    # 如果不是选项的开始，可能是选项的值，这里可以添加更多的逻辑

class InteractiveMode:
    """交互式模式类"""
    
    def __init__(self, analyzer):
        """初始化交互式模式
        
        Args:
            analyzer: K8sResourceAnalyzer实例
        """
        self.analyzer = analyzer
        self.console = Console()
        
        # 创建命令补全器
        self.commands = {
            'analyze': {
                'help': '分析资源',
                'options': {
                    '--input': '输入文件或目录',
                    '--output': '输出目录',
                    '--format': '输出格式',
                    '--parallel': '启用并行处理',
                    '--cache': '启用缓存'
                }
            },
            'health': {
                'help': '健康检查',
                'options': {
                    '--input': '输入文件或目录',
                    '--output': '输出目录',
                    '--format': '输出格式',
                    '--severity': '最小严重性级别'
                }
            },
            'dependency': {
                'help': '依赖分析',
                'options': {
                    '--input': '输入文件或目录',
                    '--output': '输出目录',
                    '--format': '输出格式',
                    '--graph': '生成依赖图',
                    '--depth': '依赖分析深度'
                }
            },
            'validate': {
                'help': '验证资源',
                'options': {
                    '--input': '输入文件或目录',
                    '--schema': '自定义验证模式',
                    '--strict': '严格模式'
                }
            },
            'convert': {
                'help': '转换资源',
                'options': {
                    '--input': '输入文件',
                    '--output': '输出文件',
                    '--format': '输出格式',
                    '--version': '目标API版本'
                }
            },
            'compare': {
                'help': '比较资源',
                'options': {
                    '--input': '输入文件或目录',
                    '--base': '基准文件或目录',
                    '--output': '输出目录',
                    '--format': '输出格式',
                    '--visual': '生成可视化比较结果'
                }
            },
            'merge': {
                'help': '合并资源',
                'options': {
                    '--input': '输入文件或目录',
                    '--output': '输出文件',
                    '--strategy': '合并策略文件'
                }
            },
            'config': {
                'help': '配置管理',
                'options': {
                    '--show': '显示当前配置',
                    '--set': '设置配置项 (格式: key=value)',
                    '--reset': '重置配置为默认值'
                }
            },
            'clear': {
                'help': '清屏'
            },
            'help': {
                'help': '显示帮助信息'
            },
            'exit': {
                'help': '退出程序'
            }
        }
        
        # 创建键绑定
        self.kb = KeyBindings()
        
        @self.kb.add('c-l')
        def _(event):
            """清屏快捷键"""
            clear()
        
        @self.kb.add('c-d')
        def _(event):
            """退出快捷键"""
            event.app.exit()
        
        # 创建嵌套补全器
        self.completer = CommandCompleter(self.commands)
        
        # 创建样式
        self.style = Style.from_dict({
            'prompt': 'ansicyan bold',
            'command': 'ansigreen bold',
            'option': 'ansiyellow bold',
            'error': 'ansired bold',
            'success': 'ansigreen bold',
            'info': 'ansiblue bold',
            'warning': 'ansiyellow bold'
        })
        
        # 获取终端尺寸
        self.terminal_width, self.terminal_height = shutil.get_terminal_size()
        
        # 创建会话
        history_file = os.path.expanduser('~/.k8s_analyzer_history')
        self.session = PromptSession(
            completer=self.completer,
            style=self.style,
            history=FileHistory(history_file),
            auto_suggest=AutoSuggestFromHistory(),
            key_bindings=self.kb,
            complete_while_typing=True,
            enable_history_search=True,
            mouse_support=True,
            complete_in_thread=True
        )
    
    def run(self):
        """运行交互式模式"""
        self._show_welcome()
        
        while True:
            try:
                # 获取用户输入
                command = self.session.prompt(
                    HTML("<ansicyan>k8s-analyzer></ansicyan> "),
                    pre_run=self._update_terminal_size
                ).strip()
                
                if not command:
                    continue
                
                # 解析命令
                parts = command.split()
                cmd = parts[0]
                args = parts[1:]
                
                # 执行命令
                if cmd == 'exit':
                    self._handle_exit()
                elif cmd == 'help':
                    self._handle_help(args)
                elif cmd == 'clear':
                    clear()
                elif cmd == 'config':
                    self._handle_config(args)
                elif cmd in self.commands:
                    self._handle_command(cmd, args)
                else:
                    self._show_error(f"未知命令: {cmd}")
                    
            except KeyboardInterrupt:
                continue
            except EOFError:
                break
            except Exception as e:
                self._show_error(f"错误: {str(e)}")
                self.console.print_exception(show_locals=True)
    
    def _update_terminal_size(self):
        """更新终端尺寸"""
        self.terminal_width, self.terminal_height = shutil.get_terminal_size()
    
    def _show_welcome(self):
        """显示欢迎信息"""
        welcome_text = """
[bold blue]Kubernetes资源分析工具[/bold blue]

可用命令:
  analyze    - 分析资源
  health     - 健康检查
  dependency - 依赖分析
  validate   - 验证资源
  convert    - 转换资源
  compare    - 比较资源
  merge      - 合并资源
  config     - 配置管理
  clear      - 清屏
  help       - 显示帮助
  exit       - 退出程序

[bold cyan]快捷键:[/bold cyan]
  Ctrl+L     - 清屏
  Ctrl+D     - 退出程序
  Tab        - 命令补全
  ↑/↓        - 历史命令

输入 'help <命令>' 获取特定命令的帮助信息
        """
        self.console.print(Panel(welcome_text, title="欢迎", border_style="blue", expand=False))
    
    def _show_error(self, message: str):
        """显示错误信息
        
        Args:
            message: 错误信息
        """
        self.console.print(f"[bold red]错误:[/bold red] {message}")
    
    def _show_success(self, message: str):
        """显示成功信息
        
        Args:
            message: 成功信息
        """
        self.console.print(f"[bold green]成功:[/bold green] {message}")
    
    def _show_info(self, message: str):
        """显示信息
        
        Args:
            message: 信息
        """
        self.console.print(f"[bold blue]信息:[/bold blue] {message}")
    
    def _show_warning(self, message: str):
        """显示警告信息
        
        Args:
            message: 警告信息
        """
        self.console.print(f"[bold yellow]警告:[/bold yellow] {message}")
    
    def _show_help(self, command: Optional[str] = None):
        """显示帮助信息
        
        Args:
            command: 命令名称
        """
        if command:
            if command in self.commands:
                info = self.commands[command]
                table = Table(title=f"命令: {command}", border_style="blue", header_style="bold cyan")
                table.add_column("选项", style="cyan")
                table.add_column("说明", style="green")
                
                table.add_row("说明", info['help'])
                if 'options' in info:
                    for opt, desc in info['options'].items():
                        table.add_row(opt, desc)
                
                self.console.print(table)
                
                # 显示使用示例
                self._show_command_examples(command)
            else:
                self._show_error(f"未知命令: {command}")
        else:
            table = Table(title="可用命令", border_style="blue", header_style="bold cyan")
            table.add_column("命令", style="cyan")
            table.add_column("说明", style="green")
            
            for cmd, info in self.commands.items():
                table.add_row(cmd, info['help'])
            
            self.console.print(table)
            
            # 显示快捷键帮助
            self._show_keyboard_shortcuts()
    
    def _show_command_examples(self, command: str):
        """显示命令使用示例
        
        Args:
            command: 命令名称
        """
        examples = {
            'analyze': [
                'analyze --input ./manifests --output ./results',
                'analyze --input ./manifests --output ./results --format markdown --parallel --cache'
            ],
            'health': [
                'health --input ./manifests --severity warning',
                'health --input ./manifests --output ./health-report --format json'
            ],
            'dependency': [
                'dependency --input ./manifests --graph',
                'dependency --input ./manifests --depth 3 --output ./deps'
            ],
            'validate': [
                'validate --input ./manifests',
                'validate --input ./manifests --schema ./custom-schema.json --strict'
            ],
            'convert': [
                'convert --input deployment.yaml --output new-deployment.yaml --version apps/v1',
                'convert --input ./manifests --output ./converted --format yaml'
            ],
            'compare': [
                'compare --input ./new --base ./old',
                'compare --input ./new --base ./old --output ./diff --visual'
            ],
            'merge': [
                'merge --input ./manifests --output merged.yaml',
                'merge --input ./manifests --output merged.yaml --strategy ./merge-strategy.yaml'
            ],
            'config': [
                'config --show',
                'config --set extraction.recursive=true',
                'config --reset'
            ]
        }
        
        if command in examples:
            panel = Panel(
                "\n".join([f"[cyan]$[/cyan] {example}" for example in examples[command]]),
                title="使用示例",
                border_style="green"
            )
            self.console.print(panel)




    def _show_keyboard_shortcuts(self):
        """显示键盘快捷键帮助"""
        table = Table(title="键盘快捷键", border_style="blue", header_style="bold cyan")
        table.add_column("快捷键", style="cyan")
        table.add_column("功能", style="green")
        
        table.add_row("Ctrl+L", "清屏")
        table.add_row("Ctrl+D", "退出程序")
        table.add_row("Tab", "命令补全")
        table.add_row("↑/↓", "浏览历史命令")
        table.add_row("Ctrl+A", "光标移到行首")
        table.add_row("Ctrl+E", "光标移到行尾")
        table.add_row("Ctrl+K", "删除光标到行尾的内容")
        table.add_row("Ctrl+U", "删除光标到行首的内容")
        
        self.console.print(table)
    
    def _handle_exit(self):
        """处理退出命令"""
        if Confirm.ask("确定要退出吗?", default=True):
            self._show_info("再见!")
            sys.exit(0)
    
    def _handle_help(self, args: List[str]):
        """处理帮助命令
        
        Args:
            args: 命令参数
        """
        if args:
            self._show_help(args[0])
        else:
            self._show_help()
    
    def _handle_config(self, args: List[str]):
        """处理配置命令
        
        Args:
            args: 命令参数
        """
        if not args:
            self._show_error("请指定配置操作: --show, --set 或 --reset")
            return
            
        if args[0] == '--show':
            # 显示当前配置
            self._show_config()
        elif args[0] == '--set' and len(args) > 1:
            # 设置配置项
            for arg in args[1:]:
                if '=' in arg:
                    key, value = arg.split('=', 1)
                    self._set_config(key, value)
                else:
                    self._show_error(f"无效的配置格式: {arg}，应为 key=value")
        elif args[0] == '--reset':
            # 重置配置
            if Confirm.ask("确定要重置所有配置为默认值吗?", default=False):
                self._reset_config()
        else:
            self._show_error("无效的配置操作")
    
    def _show_config(self):
        """显示当前配置"""
        # 这里假设analyzer有config_manager属性
        if hasattr(self.analyzer, 'config_manager'):
            config = self.analyzer.config_manager.config
            
            # 使用Rich的树形结构显示配置
            tree = Tree("[bold blue]当前配置[/bold blue]")
            
            def add_dict_to_tree(d, tree_node):
                for key, value in d.items():
                    if isinstance(value, dict):
                        branch = tree_node.add(f"[bold cyan]{key}[/bold cyan]")
                        add_dict_to_tree(value, branch)
                    else:
                        tree_node.add(f"[cyan]{key}[/cyan]: [green]{value}[/green]")
            
            add_dict_to_tree(config, tree)
            self.console.print(tree)
        else:
            self._show_error("无法访问配置管理器")
    
    def _set_config(self, key: str, value: str):
        """设置配置项
        
        Args:
            key: 配置键
            value: 配置值
        """
        # 这里假设analyzer有config_manager属性
        if hasattr(self.analyzer, 'config_manager'):
            # 解析键路径
            key_path = key.split('.')
            
            # 尝试转换值类型
            try:
                # 尝试转换为布尔值
                if value.lower() == 'true':
                    typed_value = True
                elif value.lower() == 'false':
                    typed_value = False
                # 尝试转换为整数
                elif value.isdigit():
                    typed_value = int(value)
                # 尝试转换为浮点数
                elif value.replace('.', '', 1).isdigit() and value.count('.') == 1:
                    typed_value = float(value)
                # 保持为字符串
                else:
                    typed_value = value
            except Exception:
                typed_value = value
            
            # 设置配置
            self.analyzer.config_manager.set(typed_value, *key_path)
            self.analyzer.config_manager.save()
            
            self._show_success(f"已设置配置 {key} = {typed_value}")
        else:
            self._show_error("无法访问配置管理器")
    
    def _reset_config(self):
        """重置配置为默认值"""
        # 这里假设analyzer有config_manager属性
        if hasattr(self.analyzer, 'config_manager'):
            # 重置配置
            self.analyzer.config_manager.config = self.analyzer.config_manager.DEFAULT_CONFIG.copy()
            self.analyzer.config_manager.save()
            
            self._show_success("已重置所有配置为默认值")
        else:
            self._show_error("无法访问配置管理器")
    
    def _handle_command(self, command: str, args: List[str]):
        """处理命令
        
        Args:
            command: 命令名称
            args: 命令参数
        """
        # 解析参数
        parsed_args = self._parse_args(args)
        
        # 创建进度显示
        with Progress(
            SpinnerColumn(),
            TextColumn("[bold blue]{task.description}"),
            BarColumn(bar_width=None),
            TaskProgressColumn(),
            TimeRemainingColumn(),
            expand=True
        ) as progress:
            task = progress.add_task(f"执行 {command}...", total=100)
            
            try:
                # 根据命令调用相应的处理函数
                if command == 'analyze':
                    self._handle_analyze(parsed_args, progress, task)
                elif command == 'health':
                    self._handle_health(parsed_args, progress, task)
                elif command == 'dependency':
                    self._handle_dependency(parsed_args, progress, task)
                elif command == 'validate':
                    self._handle_validate(parsed_args, progress, task)
                elif command == 'convert':
                    self._handle_convert(parsed_args, progress, task)
                elif command == 'compare':
                    self._handle_compare(parsed_args, progress, task)
                elif command == 'merge':
                    self._handle_merge(parsed_args, progress, task)
                
                self._show_success(f"{command} 执行完成")
            except Exception as e:
                self._show_error(f"{command} 执行失败: {str(e)}")
                self.console.print_exception(show_locals=True)
    
    def _parse_args(self, args: List[str]) -> Dict[str, Any]:
        """解析命令参数
        
        Args:
            args: 命令参数列表
            
        Returns:
            解析后的参数字典
        """
        parsed_args = {}
        current_key = None
        
        for arg in args:
            if arg.startswith('--'):
                # 这是一个选项
                current_key = arg[2:]  # 去掉前缀 '--'
                parsed_args[current_key] = True  # 默认为布尔值
            elif current_key:
                # 这是一个选项的值
                parsed_args[current_key] = arg
                current_key = None
        
        return parsed_args
    
    def _handle_analyze(self, args: Dict[str, Any], progress: Progress, task: int):
        """处理分析命令
        
        Args:
            args: 命令参数
            progress: 进度显示对象
            task: 任务ID
        """
        input_path = args.get('input', './sources')
        output_path = args.get('output', './outputs')
        output_format = args.get('format', 'markdown')
        use_parallel = args.get('parallel', False)
        use_cache = args.get('cache', False)
        
        # 更新进度
        progress.update(task, description=f"分析资源: {input_path}")
        progress.update(task, completed=10)
        
        # TODO: 实际实现分析逻辑
        # 这里只是示例代码
        for i in range(10, 100, 10):
            # 模拟处理过程
            import time
            time.sleep(0.5)
            progress.update(task, completed=i, description=f"分析资源: {input_path} ({i}%)")
        
        progress.update(task, completed=100, description="分析完成")
        
        # 显示结果摘要
        table = Table(title="分析结果摘要", border_style="blue", header_style="bold cyan")
        table.add_column("类型", style="cyan")
        table.add_column("数量", style="green")
        
        table.add_row("Deployment", "5")
        table.add_row("Service", "7")
        table.add_row("ConfigMap", "3")
        table.add_row("Secret", "2")
        
        self.console.print(table)
        
        self._show_info(f"详细结果已保存到: {output_path}")
    
    def _handle_health(self, args: Dict[str, Any], progress: Progress, task: int):
        """处理健康检查命令
        
        Args:
            args: 命令参数
            progress: 进度显示对象
            task: 任务ID
        """
        input_path = args.get('input', './sources')
        output_path = args.get('output', './health-report')
        output_format = args.get('format', 'markdown')
        severity = args.get('severity', 'warning')
        
        # 更新进度
        progress.update(task, description=f"健康检查: {input_path}")
        progress.update(task, completed=10)
        
        # TODO: 实际实现健康检查逻辑
        # 这里只是示例代码
        for i in range(10, 100, 10):
            # 模拟处理过程
            import time
            time.sleep(0.5)
            progress.update(task, completed=i, description=f"健康检查: {input_path} ({i}%)")
        
        progress.update(task, completed=100, description="健康检查完成")
        
        # 显示结果摘要
        table = Table(title="健康检查结果", border_style="blue", header_style="bold cyan")
        table.add_column("严重性", style="cyan")
        table.add_column("问题类型", style="green")
        table.add_column("数量", style="green")
        
        table.add_row("错误", "资源缺失", "2")
        table.add_row("警告", "资源配置不当", "5")
        table.add_row("信息", "最佳实践建议", "3")
        
        self.console.print(table)
        
        self._show_info(f"详细结果已保存到: {output_path}")
    
    def _handle_dependency(self, args: Dict[str, Any], progress: Progress, task: int):
        """处理依赖分析命令
        
        Args:
            args: 命令参数
            progress: 进度显示对象
            task: 任务ID
        """
        input_path = args.get('input', './sources')
        output_path = args.get('output', './dependency-report')
        output_format = args.get('format', 'markdown')
        generate_graph = args.get('graph', False)
        depth = args.get('depth', 3)
        
        # 更新进度
        progress.update(task, description=f"依赖分析: {input_path}")
        progress.update(task, completed=10)
        
        # TODO: 实际实现依赖分析逻辑
        # 这里只是示例代码
        for i in range(10, 100, 10):
            # 模拟处理过程
            import time
            time.sleep(0.5)
            progress.update(task, completed=i, description=f"依赖分析: {input_path} ({i}%)")
        
        progress.update(task, completed=100, description="依赖分析完成")
        
        # 显示结果摘要
        table = Table(title="依赖分析结果", border_style="blue", header_style="bold cyan")
        table.add_column("资源", style="cyan")
        table.add_column("依赖数量", style="green")
        
        table.add_row("frontend-deployment", "3")
        table.add_row("backend-deployment", "5")
        table.add_row("database-statefulset", "1")
        
        self.console.print(table)
        
        self._show_info(f"详细结果已保存到: {output_path}")
    
    def _handle_validate(self, args: Dict[str, Any], progress: Progress, task: int):
        """处理验证命令
        
        Args:
            args: 命令参数
            progress: 进度显示对象
            task: 任务ID
        """
        input_path = args.get('input', './sources')
        schema_path = args.get('schema', '')
        strict_mode = args.get('strict', False)
        
        # 更新进度
        progress.update(task, description=f"验证资源: {input_path}")
        progress.update(task, completed=10)
        
        # TODO: 实际实现验证逻辑
        # 这里只是示例代码
        for i in range(10, 100, 10):
            # 模拟处理过程
            import time
            time.sleep(0.5)
            progress.update(task, completed=i, description=f"验证资源: {input_path} ({i}%)")
        
        progress.update(task, completed=100, description="验证完成")
        
        # 显示结果摘要
        table = Table(title="验证结果", border_style="blue", header_style="bold cyan")
        table.add_column("资源", style="cyan")
        table.add_column("状态", style="green")
        table.add_column("消息", style="green")
        
        table.add_row("deployment.yaml", "✅ 通过", "")
        table.add_row("service.yaml", "✅ 通过", "")
        table.add_row("configmap.yaml", "❌ 失败", "缺少必要字段")
        
        self.console.print(table)
    
    def _handle_convert(self, args: Dict[str, Any], progress: Progress, task: int):
        """处理转换命令
        
        Args:
            args: 命令参数
            progress: 进度显示对象
            task: 任务ID
        """
        input_path = args.get('input', '')
        output_path = args.get('output', '')
        output_format = args.get('format', 'yaml')
        target_version = args.get('version', '')
        
        if not input_path:
            self._show_error("请指定输入文件或目录")
            return
            
        if not output_path:
            self._show_error("请指定输出文件或目录")
            return
        
        # 更新进度
        progress.update(task, description=f"转换资源: {input_path}")
        progress.update(task, completed=10)
        
        # TODO: 实际实现转换逻辑
        # 这里只是示例代码
        for i in range(10, 100, 10):
            # 模拟处理过程
            import time
            time.sleep(0.5)
            progress.update(task, completed=i, description=f"转换资源: {input_path} ({i}%)")
        
        progress.update(task, completed=100, description="转换完成")
        
        self._show_success(f"已将资源从 {input_path} 转换并保存到 {output_path}")
        
        # 如果指定了版本转换，显示版本信息
        if target_version:
            self._show_info(f"已将API版本转换为: {target_version}")
    
    def _handle_compare(self, args: Dict[str, Any], progress: Progress, task: int):
        """处理比较命令
        
        Args:
            args: 命令参数
            progress: 进度显示对象
            task: 任务ID
        """
        input_path = args.get('input', '')
        base_path = args.get('base', '')
        output_path = args.get('output', './comparison')
        output_format = args.get('format', 'markdown')
        visual = args.get('visual', False)
        
        if not input_path:
            self._show_error("请指定输入文件或目录")
            return
            
        if not base_path:
            self._show_error("请指定基准文件或目录")
            return
        
        # 更新进度
        progress.update(task, description=f"比较资源: {input_path} 与 {base_path}")
        progress.update(task, completed=10)
        
        # TODO: 实际实现比较逻辑
        # 这里只是示例代码
        for i in range(10, 100, 10):
            # 模拟处理过程
            import time
            time.sleep(0.5)
            progress.update(task, completed=i, description=f"比较资源: {input_path} ({i}%)")
        
        progress.update(task, completed=100, description="比较完成")
        
        # 显示结果摘要
        table = Table(title="比较结果", border_style="blue", header_style="bold cyan")
        table.add_column("资源", style="cyan")
        table.add_column("变更类型", style="green")
        table.add_column("变更数量", style="green")
        
        table.add_row("deployment.yaml", "修改", "5")
        table.add_row("service.yaml", "无变化", "0")
        table.add_row("configmap.yaml", "新增", "1")
        table.add_row("secret.yaml", "删除", "1")
        
        self.console.print(table)
        
        self._show_info(f"详细比较结果已保存到: {output_path}")
        
        # 如果启用了可视化
        if visual:
            self._show_info("已生成可视化比较结果")
    
    def _handle_merge(self, args: Dict[str, Any], progress: Progress, task: int):
        """处理合并命令
        
        Args:
            args: 命令参数
            progress: 进度显示对象
            task: 任务ID
        """
        input_path = args.get('input', '')
        output_path = args.get('output', '')
        strategy_path = args.get('strategy', '')
        
        if not input_path:
            self._show_error("请指定输入文件或目录")
            return
            
        if not output_path:
            self._show_error("请指定输出文件")
            return
        
        # 更新进度
        progress.update(task, description=f"合并资源: {input_path}")
        progress.update(task, completed=10)
        
        # TODO: 实际实现合并逻辑
        # 这里只是示例代码
        for i in range(10, 100, 10):
            # 模拟处理过程
            import time
            time.sleep(0.5)
            progress.update(task, completed=i, description=f"合并资源: {input_path} ({i}%)")
        
        progress.update(task, completed=100, description="合并完成")
        
        # 显示结果摘要
        self._show_success(f"已将资源从 {input_path} 合并并保存到 {output_path}")
        
        # 如果使用了自定义合并策略
        if strategy_path:
            self._show_info(f"使用合并策略: {strategy_path}")